package com.springboot.java;

import java.lang.reflect.Field;

/**
 * @Author: TongRui乀
 * @Date: 2020/3/28 16:09
 * @description：
 */
public class TestJava {

    /**
     *  交换两个引用对象的值
     *
     *  Integer等基本数据类型在这里需要注意的：
     *      1 基本数据类型 如 Integer Short等都是有缓存对象的
     *      2 如果仅在交换方法中交换了两个参数对象的引用值，对方法调用方的对象没有实际影响的
     *      3 需要改变的是参数对象引用的对象的值，在这里也就是要修改Integer缓存的对象new Integer(1) 和 new Integer(2)的值
     *
     * @param numa
     * @param numb
     * @throws Exception
     */
    private static void swap(Integer numa, Integer numb) throws Exception {
        //请实现
        Field field = Integer.class.getDeclaredField("value");

        field.setAccessible(true);

        // 交换变量是int常量 不能是包装对象
        int swap = numa.intValue();

        field.set(numa, numb);

        field.set(numb, new Integer(swap));

        String a ;

    }

    private static void test_01() throws Exception {

        Integer a = 1;
        Integer b = 2;
        System.out.println("a=" + a + ",b=" + b);
        swap(a, b);
        System.out.println("a=" + a + ",b=" + b);

        Integer c = new Integer(1);

        System.out.println(a.equals(Integer.valueOf(1)));

        System.out.println(Runtime.getRuntime().maxMemory());

    }

    /**
     *
     * @description 数据类型转换测试
     * @author TongRui乀
     * @date 2020/7/25 9:40
     * @param []
     * @return void
     */
    private static void test(){

        char test  = '你';

        short a = 1;
        // 需要类型转换
//        a = a+1;
        // 会自动类型转换
        a+=1;

        Integer b = 3;

        int c = 3;

        Integer d = new Integer(3);

        System.out.println(b == d);
    }

    /**
     *
     * @description  包装对象测试
     * @author TongRui乀
     * @date 2020/7/25 9:40
     * @param []
     * @return void
     */
    private static void test_02(){

        Integer a = 100 , b = 100, c = 128, d = 127;

        Integer e = new Integer(100);

        System.err.println(a == b);;    // 在缓存访问内的数值 直接获取的是缓存的引用 所以是一样的

        System.err.println(c == d);

        System.err.println(a == e);      //   == 比较的是引用
        System.err.println(a.equals(e));  // equals 比较的值
    }

    /**
     *
     * @description 测试 常量池
     * @author TongRui乀
     * @date 2020/7/25 9:48
     * @param []
     * @return void
     */
    private static  void test_03(){

        /*String s1 = new StringBuilder("go").append("od").toString();
        System.out.println(s1.intern() == s1);  // true

        String s2 = new String("goods");

        System.out.println(s2.intern() == s2);  // false*/

        String s1 = "Programming";
        String s2 = new String("Programming");
        String s3 = "Program";
        String s4 = "ming";
        String s5 = "Program" + "ming";
        String s6 = s3 + s4;
        System.out.println(s1 == s2);   // false
        System.out.println(s1 == s5);   // true
        System.out.println(s1 == s6);   // false
        System.out.println(s1 == s6.intern());// true
        System.out.println(s2 == s2.intern());// false

    }


    private static  void test_04(){

        System.out.println(1 << 4);
        System.out.println(2 << 3);

    }

    private static  String test_04(String str){

        return str;
    }

    private static  void test_05(){
        A ab = new B();
        ab = new B();

    }

    private static void test_06(){
        String str = "str";

        Integer value = Integer.valueOf(str);

        System.out.println(value);
    }

    public static void main(String[] args) throws Exception {
        test_06();

    }

}


class A {
    static {
        System.out.print("1");
    }
    public A() {
        System.out.print("2");
    }
}
class B extends A{
    static {
        System.out.print("a");
    }
    public B() {
        System.out.print("b");
    }
}
